// import { RequestContext } from "@smithy/types";
// import { ConnectConfiguration } from "@smithy/types";
// import { ConnectionManager, ConnectionManagerConfiguration } from "@smithy/types";
// import http2, { ClientHttp2Session } from "http2";
//
// import { NodeHttp2ConnectionPool } from "./node-http2-connection-pool";
//
// /**
//  * @public
//  */
// export class NodeHttp2ConnectionManager implements ConnectionManager<ClientHttp2Session> {
//   constructor(config: ConnectionManagerConfiguration) {
//     this.config = config;
//
//     if (this.config.maxConcurrency && this.config.maxConcurrency <= 0) {
//       throw new RangeError("maxConcurrency must be greater than zero.");
//     }
//   }
//
//   private config: ConnectionManagerConfiguration;
//
//   private readonly sessionCache: Map<string, NodeHttp2ConnectionPool> = new Map<string, NodeHttp2ConnectionPool>();
//
//   public lease(requestContext: RequestContext, connectionConfiguration: ConnectConfiguration): ClientHttp2Session {
//     const url = this.getUrlString(requestContext);
//
//     const existingPool = this.sessionCache.get(url);
//
//     if (existingPool) {
//       const existingSession = existingPool.poll();
//       if (existingSession && !this.config.disableConcurrency) {
//         return existingSession;
//       }
//     }
//
//     const session = http2.connect(url);
//
//     if (this.config.maxConcurrency) {
//       session.settings({ maxConcurrentStreams: this.config.maxConcurrency }, (err) => {
//         if (err) {
//           throw new Error(
//             "Fail to set maxConcurrentStreams to " +
//               this.config.maxConcurrency +
//               "when creating new session for " +
//               requestContext.destination.toString()
//           );
//         }
//       });
//     }
//
//     // AWS SDK does not expect server push streams, don't keep node alive without a request.
//     session.unref();
//
//     const destroySessionCb = () => {
//       session.destroy();
//       this.deleteSession(url, session);
//     };
//     session.on("goaway", destroySessionCb);
//     session.on("error", destroySessionCb);
//     session.on("frameError", destroySessionCb);
//     session.on("close", () => this.deleteSession(url, session));
//
//     if (connectionConfiguration.requestTimeout) {
//       session.setTimeout(connectionConfiguration.requestTimeout, destroySessionCb);
//     }
//
//     const connectionPool = this.sessionCache.get(url) || new NodeHttp2ConnectionPool();
//
//     connectionPool.offerLast(session);
//
//     this.sessionCache.set(url, connectionPool);
//
//     return session;
//   }
//
//   /**
//    * Delete a session from the connection pool.
//    * @param authority The authority of the session to delete.
//    * @param session The session to delete.
//    */
//   public deleteSession(authority: string, session: ClientHttp2Session): void {
//     const existingConnectionPool = this.sessionCache.get(authority);
//
//     if (!existingConnectionPool) {
//       return;
//     }
//
//     if (!existingConnectionPool.contains(session)) {
//       return;
//     }
//
//     existingConnectionPool.remove(session);
//
//     this.sessionCache.set(authority, existingConnectionPool);
//   }
//
//   public release(requestContext: RequestContext, session: ClientHttp2Session): void {
//     const cacheKey = this.getUrlString(requestContext);
//     this.sessionCache.get(cacheKey)?.offerLast(session);
//   }
//
//   public destroy(): void {
//     for (const [key, connectionPool] of this.sessionCache) {
//       for (const session of connectionPool) {
//         if (!session.destroyed) {
//           session.destroy();
//         }
//         connectionPool.remove(session);
//       }
//       this.sessionCache.delete(key);
//     }
//   }
//
//   public setMaxConcurrentStreams(maxConcurrentStreams: number) {
//     if (maxConcurrentStreams && maxConcurrentStreams <= 0) {
//       throw new RangeError("maxConcurrentStreams must be greater than zero.");
//     }
//     this.config.maxConcurrency = maxConcurrentStreams;
//   }
//
//   public setDisableConcurrentStreams(disableConcurrentStreams: boolean) {
//     this.config.disableConcurrency = disableConcurrentStreams;
//   }
//
//   private getUrlString(request: RequestContext): string {
//     return request.destination.toString();
//   }
// }
